#pragma once

#include "session.hpp"
#include "matcher.hpp"

#define WWWROOT "./wwwroot"

class gobang_server
{
public:
    gobang_server(const std::string &host,
                  const std::string &username,
                  const std::string &password,
                  const std::string &dbname,
                  uint16_t port = 3306,
                  const std::string &wwwroot = WWWROOT)
        : _web_root(wwwroot),
          _ut(host, username, password, dbname, port),
          _rm(&_ut, &_om),
          _sm(&_wssrv),
          _mm(&_rm, &_ut, &_om)

    {
        // 2.设置日志等级
        _wssrv.set_access_channels(websocketpp::log::alevel::none); // 不输出

        // 3.初始化asio调度器
        _wssrv.init_asio();
        _wssrv.set_reuse_addr(true); // 启动地址重用
        // 4.设置回调函数
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback, this, std::placeholders::_1, std::placeholders::_2));
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
    }
    void start(int port)
    {
        // 5.设置监听窗口
        _wssrv.listen(port);
        // 6.开始获取新链接
        _wssrv.start_accept();
        // 7.启动服务器
        _wssrv.run();
    }

private:
    // 静态资源的请求
    void file_handle(wsserver_t::connection_ptr &conn)
    {
        // 1. 获取uri的资源路径，了解客户端的页面文件名称
        websocketpp::http::parser::request req = conn->get_request(); // 获取请求，可以得到uri
        std::string method = req.get_method();
        std::string uri = req.get_uri();
        // 2. 组合文件的实际路径
        std::string pathname = _web_root + uri;
        // 3. 如果请求的是根目录，增加一个后缀 login.html
        if (uri == "/")
        {
            pathname += "login.html";
        }
        // 4. 读取文件内容
        // Json::Value resp_json;
        std::string body;
        bool res = file_util::read(pathname, body);
        // 4.1 文件打开失败，返回的是404
        if (!res)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='utf-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1>not found</h1>";
            body += "</body>";
            body += "</html>";
            conn->set_status(websocketpp::http::status_code::not_found);
        }
        // 5. 设置相应正文
        if (res)
            conn->set_status(websocketpp::http::status_code::ok);
        conn->set_body(body);
    }
    void http_resp(bool result, websocketpp::http::status_code::value code,
                   const std::string &reason, wsserver_t::connection_ptr &conn)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        std::string resp_body;
        json_util::Serialize(resp_json, resp_body);
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("Content-Type", "application/json");
        return;
    }
    // 动态资源注册的请求
    void reg(wsserver_t::connection_ptr &conn)
    {
        // websocketpp::http::parser::request req = conn->get_request();
        //  1. 获取请求正文
        std::string req_body = conn->get_request_body();
        // 2. 对正文进行json反序列化，得到用户名和密码
        Json::Value login_info;
        Json::Value resp_json;
        bool res = json_util::UnSerialize(req_body, login_info);
        if (!res)
        {
            DBG_LOG("反序列化失败");
            return http_resp(false, websocketpp::http::status_code::bad_request, "请求的正文格式错误", conn);
        }
        // 3. 进行数据库的用户新增操作
        if (login_info["username"].isNull() || login_info["password"].isNull())
        {
            DBG_LOG("用户名密码不完整");
            return http_resp(false, websocketpp::http::status_code::bad_request, "请输入用户名或密码", conn);
        }
        res = _ut.insert(login_info);
        if (!res)
        {
            DBG_LOG("用户插入失败");
            return http_resp(false, websocketpp::http::status_code::bad_request, "用户名已经被占用", conn);
        }
        return http_resp(true, websocketpp::http::status_code::ok, "注册用户成功", conn);
    }
    // 动态资源登陆的请求
    void login(wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求正文，得到用户名和密码
        std::string req_body = conn->get_request_body();
        Json::Value login_info;
        bool res = json_util::UnSerialize(req_body, login_info);
        if (!res)
        {
            DBG_LOG("反序列化失败");
            return http_resp(false, websocketpp::http::status_code::bad_request, "请求的正文格式错误", conn);
        }
        // 2.校验完整性
        if (login_info["username"].isNull() || login_info["password"].isNull())
        {
            DBG_LOG("用户名密码不完整");
            return http_resp(false, websocketpp::http::status_code::bad_request, "请输入用户名或密码", conn);
        }
        res = _ut.login(login_info);
        if (!res)
        {
            DBG_LOG("用户名密码错误");
            return http_resp(false, websocketpp::http::status_code::bad_request, "用户名密码错误", conn);
        }
        // 3.如果校验成功了，给客户端创建session
        uint64_t uid = login_info["id"].asInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN_OK);
        if (!ssp.get())
        {
            DBG_LOG("创建会话失败");
            return http_resp(false, websocketpp::http::status_code::internal_server_error, "创建会话失败", conn);
        }
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
        // 4.设置响应头部：Set_Cookie 将sessionid通过session返回
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->get_ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        return http_resp(true, websocketpp::http::status_code::ok, "登陆成功", conn);
    }

    bool get_cookie_val(const std::string &cookie_str, const std::string &key, std::string &val)
    {
        // Cookie: SSID=xxxx; path=/;
        // 1.以; 为间隔符，对字符串进行分割
        std::string sep = "; ";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie_str, sep, cookie_arr);
        // 2.对单个的cookie字符串，以 = 为间隔进行分割，得到key和val
        for (auto &str : cookie_arr)
        {
            std::vector<std::string> tem_arr;
            string_util::split(str, "=", tem_arr);
            if (tem_arr.size() != 2)
            {
                continue;
            }
            if (tem_arr[0] == key)
            {
                val = tem_arr[1];
                return true;
            }
        }
        return false;
    }
    // 用户信息获取功能的请求
    void info(wsserver_t::connection_ptr &conn)
    {
        // Json::Value err_json;
        // 1.获取请求信息中的cookie，获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // 如果没有cookie，返回错误，让客户端重新登陆
            return http_resp(false, websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登陆", conn);
        }
        // 1.5取出ssid
        std::string ssid_str;
        bool res = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (!res)
        {
            // cookie中如果没有ssid，返回错误，让客户端重新登陆
            return http_resp(false, websocketpp::http::status_code::bad_request, "找不到ssid信息，请重新登陆", conn);
        }
        // 2.获取对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            // 没有的话认为登陆过期了
            return http_resp(false, websocketpp::http::status_code::bad_request, "登陆过期，请重新登陆", conn);
        }

        // 3.从数据库中取出用户数据，进行序列化发送给客户端
        uint64_t uid = ssp->get_user();
        Json::Value user;
        res = _ut.select_by_id(uid, user);
        if (!res)
        {
            // 获取用户信息失败，返回错误
            return http_resp(false, websocketpp::http::status_code::bad_request, "找不到用户信息", conn);
        }
        std::string body;
        json_util::Serialize(user, body);
        conn->set_body(body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        // 4.刷新过期时间
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
    }
    void http_callback(websocketpp::connection_hdl hdl)
    {
        // 直接获取的是静态的html，没有css等
        // std::string filename = "register.html";

        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取请求，可以得到uri
        // 获取方法和uri
        std::string method = req.get_method();
        std::string uri = req.get_uri();
        std::cout << method << std::endl;
        std::cout << uri << std::endl;
        if (method == "POST" && uri == "/reg")
        {
            DBG_LOG("进入注册请求");
            reg(conn);
        }
        else if (method == "POST" && uri == "/login")
        {
            login(conn);
        }
        else if (method == "GET" && uri == "/info")
        {
            info(conn);
        }
        else
        {
            DBG_LOG("来了");
            file_handle(conn);
        }
    }
    void ws_resp(wsserver_t::connection_ptr conn, Json::Value &resp)
    {
        std::string body;
        json_util::Serialize(resp, body);
        conn->send(body);
    }
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
    {
        Json::Value err_resp;
        // 1.1 获取请求信息中的cookie，获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // 如果没有cookie，返回错误，让客户端重新登陆
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到cookie信息，请重新登陆";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        // 1.2 取出ssid
        std::string ssid_str;
        bool res = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (!res)
        {
            // cookie中如果没有ssid，返回错误，让客户端重新登陆
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到ssid信息，请重新登陆";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        // 1.3获取对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            // 没有的话认为登陆过期了
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "登陆过期，请重新登陆";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        return ssp;
    }
    void wsopen_game_hall(wsserver_t::connection_ptr conn)
    {
        // 游戏大厅长链接建立成功
        Json::Value err_resp;
        //  1.登陆验证，判断当前的客户端是否已经成功登陆
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.判断当前的客户端是否重复登陆
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "玩家重复登陆";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return;
        }
        // 3.将当前客户端以及连接加入游戏大厅
        _om.enter_game_hall(ssp->get_user(), conn);
        // 4.给客户端响应客户端的游戏大厅建立成功
        Json::Value resp_json;
        resp_json["optype"] = "hall_ready";
        resp_json["result"] = true;
        ws_resp(conn, resp_json);
        // 5.将session设置为永久存在
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
    }
    void wsopen_game_room(wsserver_t::connection_ptr conn)
    {
        Json::Value err_resp;
        // 1.获取当前客户端的session
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.判断当前客户端是否已经在游戏房间或者大厅中
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            err_resp["optype"] = "room_ready";
            err_resp["reason"] = "玩家重复登陆";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return;
        }
        // 3.判断当前客户端是否已经创建好了房间
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            err_resp["optype"] = "room_ready";
            err_resp["reason"] = "没有找到玩家的房间信息";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return;
        }
        // 4.将当前用户添加到在线用户管理的房间中
        _om.enter_game_room(ssp->get_user(), conn);
        // 5.将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_FOREVER);
        // 6.回复房间准备完毕
        Json::Value resp_json;
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = static_cast<Json::UInt64>(rp->GetRoomId());
        resp_json["uid"] = static_cast<Json::UInt64>(ssp->get_user());
        resp_json["white_id"] = static_cast<Json::UInt64>(rp->GetWhiteId());
        resp_json["black_id"] = static_cast<Json::UInt64>(rp->GetBlackId());
        return ws_resp(conn, resp_json);
    }

    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        // websocket长链接请求，建立成功之后的处理函数
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取请求，可以得到uri
        // 获取方法和uri
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            return wsopen_game_hall(conn);
        }
        else if (uri == "/room")
        {
            return wsopen_game_room(conn);
        }
    }
    void wsclose_game_hall(wsserver_t::connection_ptr conn)
    {
        // 游戏大厅长连接断开的处理
        //  1.登陆验证，判断当前的客户端是否已经成功登陆
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 1.将玩家从游戏大厅移除
        _om.exit_game_hall(ssp->get_user());
        // 2.将会话设置定时销毁
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
    }
    void wsclose_game_room(wsserver_t::connection_ptr conn)
    {
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 1.将玩家从在线用户的房间中移除
        _om.exit_game_room(ssp->get_user());
        // 2.session恢复生命周期
        _sm.set_session_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
        // 3.将玩家从游戏房间中移除，房间里用户没了，自动销毁房间
        _rm.remove_room_user(ssp->get_user());
    }
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        // websocket长链接请求，建立成功之后的处理函数
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取请求，可以得到uri
        // 获取方法和uri
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            return wsclose_game_hall(conn);
        }
        else if (uri == "/room")
        {
            return wsclose_game_room(conn);
        }
    }
    void wsmsg_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        // 1.登陆验证，判断当前的客户端是否已经成功登陆
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.获取请求信息
        std::string req_body = msg->get_payload();
        Json::Value req_json;
        bool res = json_util::UnSerialize(req_body, req_json);
        if (!res)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息解析失败";
            return ws_resp(conn, resp_json);
        }
        // 3.对于请求进行处理
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            //  开始对战匹配：将用户添加到匹配队列中
            _mm.add(ssp->get_user());
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            //  停止对战匹配：移除
            _mm.del(ssp->get_user());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        // 4.给客户端响应
        resp_json["optype"] = "unknow";
        resp_json["result"] = false;
        return ws_resp(conn, resp_json);
    }
    void wsmsg_game_room(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value err_resp;
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.获取客户端房间信息
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp == nullptr)
        {
            err_resp["optype"] = "unkown";
            err_resp["reason"] = "没有找到玩家的房间信息";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return;
        }
        // 3.对消息进行反序列化
        Json::Value req_json;
        std::string req_body = msg->get_payload();
        bool res = json_util::UnSerialize(req_body, req_json);
        if (!res)
        {
            err_resp["optype"] = "unkown";
            err_resp["reason"] = "请求解析失败";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return;
        }
        // 4.通过房间模块进行消息请求的处理
        return rp->handle_request(req_json);
    }
    void wsmsg_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        // websocket长链接请求，建立成功之后的处理函数
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取请求，可以得到uri
        // 获取方法和uri
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            return wsmsg_game_hall(conn, msg);
        }
        else if (uri == "/room")
        {
            return wsmsg_game_room(conn, msg);
        }
    }

private:
    std::string _web_root; // 静态资源根目录 ./wwwroot  /register.html -> ./wwwroot/register.html
    wsserver_t _wssrv;
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    session_manager _sm;
    matcher _mm;
};